package com.fqy.gmall.product.controller.test;

import java.util.concurrent.*;

/**
 * User: fqy
 * Date: 2021/9/28
 * Time: 9:16
 * Describe:
 */
public class CompletableFutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //  串行
        //  runAsync方法不支持返回值
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("来了，老弟！");
//        });
//        completableFuture.get();//输出 来了，老弟！
//        //  supplyAsync可以支持返回值
//        CompletableFuture.supplyAsync(()->{
//            System.out.println("有返回值的.... 我们过节了...");
//            int i = 1/0;
//            return 1024;
//        })
//        .thenApply((t)->{
//            System.out.println("t----------:"+t);
//            return t*2;
//        })
//        .whenComplete((t,u)->{
//            //  第一个参数：表示上一个线程的返回值！
//            //  第二个参数：是否有异常信息存在！
//            System.out.println("有返回值的......."+t);
//            System.out.println("有返回值的......."+u);
//        })
//        .exceptionally((t)->{
//            System.out.println("exceptionally......."+t);
//            return 404;
//            })
//        ;
        //并行
//        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
//                8, //  看cpu 密集型 n+1，还是io 密集型：2*n 核心线程数
//                100,
//                3L,
//                TimeUnit.SECONDS,
//                new ArrayBlockingQueue<>(3),
//                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy() // 如果线程处理不了了，直接抛出异常！
//        );
//
//        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
//            return "hello";
//        },threadPoolExecutor);
//        //  创建一个B线程 创建一个C线程
//        CompletableFuture<Void> threadB = completableFuture.thenAcceptAsync((t) -> {
//            //  睡眠
//
//            //  打印
//            printCurrTime(t+":\t 第一个线程");
//        },threadPoolExecutor);
//        CompletableFuture<Void> completableFutureC = completableFuture.thenAcceptAsync((t) -> {
//            //  睡眠
//            sleep(3);
//            //  打印
//            System.out.println(t+":\t 第二个线程");
//        },threadPoolExecutor);
        //  定义线程池： 7 个
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                8, //  看cpu 密集型 n+1，还是io 密集型：2*n 核心线程数
                11,
                3L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() // 如果线程处理不了了，直接抛出异常！
        );
        //  并行！
        CompletableFuture<String> completableFutureA = CompletableFuture.supplyAsync(() -> {
            return "hello";
        },threadPoolExecutor);

        //  创建一个B线程 创建一个C线程
        CompletableFuture<Void> completableFutureB = completableFutureA.thenAcceptAsync((t) -> {
            //  睡眠
            delaySec(3);
            //  打印
            printCurrTime(t+":\t 第一个线程");
        },threadPoolExecutor);
        CompletableFuture<Void> completableFutureC = completableFutureA.thenAcceptAsync((t) -> {
            //  睡眠
            delaySec(1);
            //  打印
            printCurrTime(t+":\t 第二个线程");
        },threadPoolExecutor);

        completableFutureB.get();
        completableFutureC.get();
    }
    private static void printCurrTime(String s) {
        System.out.println(s);
    }

    private static void delaySec(int i) {
        try {
            Thread.sleep(i*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
